What

Wires the F3 tx-completeness broadcast gate into the actual send path and fixes the F2 mark-before-send share loss, for BTC, DGB and BCH. Both fixes are ports of the already-correct DASH implementation (src/impl/dash/node.cpp). Builds on #868 (c77dc03), which landed the BTC primitives header.

Reachability, up front. BTC and BCH are protected at runtime by this PR. DGB is only partly protected — its broadcast_share is dead code today (#884). See the Reachability section before reading the rest.

FIX A — F3 tx-completeness broadcast gate

send_shares() built its remember_tx forward with

auto it = m_known_txs.find(th);
if (it != m_known_txs.end())
    full_txs.emplace_back(it->second);

with no else branch: a referenced tx whose bytes we do not hold was silently omitted and the share was written to the peer regardless. Canonical p2pool then drops the connection on referenced unknown transaction (p2p.py), which isolates us from the sharechain and orphans our shares.

This is reachable in normal operation: shares pulled via sharereply arrive without their tx bytes.

send_shares() now filters its outgoing batch through partition_backable() before building needed_txs. The gate keys on the bytes in m_known_txs, not on the peer's have_tx advert — that advert can be stale (the peer may have dropped the tx), and sending hash-only for a tx the peer no longer holds is exactly the disconnect. m_remote_txs is still used only to choose the hash-vs-bytes encoding. The now-unreachable omission branch increments a missing counter and logs a warning (defence in depth, mirroring DASH).

Live on all three coins.

FIX B — mark / record only what was actually sent

send_shares() returned void, so callers could not tell what it wrote. It now returns the hashes actually written. Two callers consume that:

broadcast_share() (BTC, BCH live; DGB pre-wiring) inserted each walked hash into m_shared_share_hashes inside the chain-walk loop, before send_shares ran. send_shares has abandon paths — tracker try_to_lock miss, empty batch, and now the F3 gate — and a zero-peer m_peers abandons the batch too. A marked-but-unsent share is lost permanently: the next walk breaks on the first marked hash, so nothing ever re-pushes it. It now marks only accepted hashes, after the peer loop, via broadcast_and_mark().

readvertise_best_share() (DGB only — DGB's live path) recorded the offered batch into m_last_broadcast_to. That record is what a peer disconnect within 10 s converts into m_rejected_share_hashes, and the readvertise walk continues past rejected hashes permanently. Recording the offered batch lets a share the F3 gate merely withheld be blamed for someone else's disconnect, turning a transient, self-healing skip into permanent exclusion from every future re-advert. Since DGB re-advertises peer-received shares, that is a propagation loss for the whole sharechain, not just for us. Now extracted into readvertise_and_record(): records what was written, and records nothing at all for a peer that received nothing. BTC/BCH m_last_broadcast_to gets the same treatment inside broadcast_and_mark.

Reachability (caller-side trace — verified independently)

DGB detail, all re-verified against this branch:

• set_mint_share_fn, set_create_share_fn, broadcast_share, notify_local_share — zero occurrences in main_dgb.cpp. The only set_mint_share_fn binding in the tree is main_dash.cpp:1854, plus DGB's own work_source_test.cpp.
• dgb::NodeImpl::broadcast_share and notify_local_share have zero callers repo-wide (definitions and comments only). try_mint_share always takes the null-fn branch at dgb/stratum/work_source.cpp:810-814 and logs set_mint_share_fn unbound. Tracked as dgb: set_mint_share_fn is never bound in main_dgb.cpp — DGB cannot mint local shares #884.
• readvertise_best_share() is live: called at dgb/node.cpp:1767 on best-change and armed on a 10 s one-shot timer at :1774, both from the think IO-phase.

What that means for DGB in this PR

Chosen: keep the DGB broadcast_share half, labelled as pre-wiring. Rationale: dropping it would leave a known mark-before-send bug in a function that #884 is going to bind, so whoever wires the mint seam would ship the loss; and the repo's per-coin symmetry posture means the three node.cpp bodies should stay identical. It is zero-risk because it is dead. It is labelled in three places so nobody mistakes it for protection:

• a PRE-WIRING — NOT REACHED ON DGB TODAY (#884) block above dgb::NodeImpl::broadcast_share;
• a DGB REACHABILITY block in src/impl/dgb/known_txs_retention.hpp marking each primitive LIVE vs PRE-WIRED;
• the DGB test suite name DgbBroadcastMarkingPrewired_NotReachedToday.

DGB tests were rescoped onto the reachable path. The previous revision's DGB KAT modelled the broadcast_share de-dup walk — i.e. an unreachable function. That is the shape of the #873 LTC miss, where the test and its negative control both passed against code production never runs. It is replaced by DgbReadvertiseRecording, which drives readvertise_and_record — the primitive readvertise_best_share actually calls. No DGB case constructs or broadcasts a locally minted share.

BTC/BCH ROOT-2 re-advert under the new marking rule

Asked for explicitly, and checked. btc/node.cpp:1053-1061 and bch/node.cpp:1056-1064 implement readvertise_best() as a plain call into broadcast_share, so the ROOT-2 walk still breaks on the first hash in m_shared_share_hashes — unlike LTC/DGB, which have a dedicated de-dup-bypassing readvertise_best_share().

The change is monotonically safe. Post-fix marking is a strict subset of pre-fix marking (only hashes a peer actually accepted). The walk therefore breaks later or in the same place, never earlier, so ROOT-2 re-pushes a superset of what it used to. Specifically:

• Head shares broadcast while no peer was connected, or whose batch every peer abandoned: previously marked and permanently unreachable to the re-advert; now unmarked, so a peer that handshook during the empty window does receive them. Strictly better — this is the exact scenario ROOT-2 exists for.
• Head shares already accepted by some other peer: still marked, walk still breaks. Unchanged from before.

So BTC/BCH ROOT-2 behaves as intended and is improved, but this PR does not fully close it — that still needs the LTC/DGB-style de-dup-bypass readvertise. Pre-existing gap, out of scope, documented in a comment at both call sites. No behavioural change was made to readvertise_best() itself.

Consensus / reward safety

No consensus or minting semantics change. Every change decides only whether we put a share on the wire. Share bytes, minting, PPLNS weighting and payout are untouched. A withheld share stays in our chain and is re-offered on the next broadcast/re-advert once its tx bytes arrive.

Skipping costs no propagation: a share we downloaded is by definition already on the network we fetched it from.

Verified file:line claims (corrections to the issue text)

Additional findings not in the issue:

• The three send_shares / broadcast_share bodies were byte-identical across btc/dgb/bch, so one patch applied cleanly to all three.
• Unlike DASH, BTC/DGB/BCH send_shares takes the tracker shared_lock itself (DASH's caller holds it). Left as-is.
• DGB has a fourth send_shares call site — readvertise_best_share() — that BTC/BCH lack. It turns out to be DGB's only live one.
• BTC/DGB/BCH have no register_template_txs / rolling template window and no add_local_share; they use core::evict_known_txs_to_cap + m_known_txs_order. So retain_template_txs ships (for btc: F3 known-txs retention/backable primitives + unit KAT #868 symmetry, with KAT coverage) but is not wired, and there is no decline-mint call site to port — the DASH add_local_share decline has no analogue here.

Tests

Folded into existing allowlisted CI targets — no new add_executable, no .github/workflows change (check_test_target_allowlist.py passes):

The bch test tree is plain int main()/assert with no GTest, so a second source cannot carry its own main(). The BCH TU instead exposes run_share_broadcast_gate_checks() and the host main() calls it — same "ride an allowlisted executable" pattern, no NOT_BUILT sentinel.

Mutation evidence (tests are load-bearing)

Gate deleted (if (all_txs_backable(...)) -> if (true)):

[  FAILED  ] BtcBroadcastGate.GateWithholdsUnbackedShare
[  FAILED  ] BtcBroadcastGate.WholeBatchUnbackedEmptiesTheSend
[  FAILED  ] DgbBroadcastGate.GateWithholdsUnbackedShare
[  FAILED  ] DgbBroadcastGate.WholeBatchUnbackedEmptiesTheSend
  FAIL: F3 gate skips exactly the unbacked share            (bch)
  FAIL: F3 gate keeps the two backable shares               (bch)
  FAIL: F3 gate skips a wholly-unbacked batch               (bch)
  FAIL: F3 gate empties a wholly-unbacked batch             (bch)

Pre-fix F2 restored — mark the offered batch instead of what was sent (btc/bch, the live broadcast_share path):

[  FAILED  ] BtcBroadcastMarking.NothingMarkedWhenNoPeerAccepted
[  FAILED  ] BtcBroadcastMarking.NothingMarkedWithZeroPeers
[  FAILED  ] BtcBroadcastMarking.OnlyAcceptedHashesAreMarked
[  FAILED  ] BtcBroadcastMarking.WalkStrandedWhenMarkedBeforeSend
  FAIL: F2 marks nothing when no peer accepted              (bch)
  FAIL: F2 marks nothing with zero peers                    (bch)
  FAIL: F2 leaves a withheld share un-marked                (bch)
  FAIL: shipped ordering marks nothing on an abandoned send (bch)
  FAIL: shipped ordering re-offers the batch                (bch)

DGB live path (readvertise_and_record) — record the offered batch instead of what was written:

[  FAILED  ] DgbReadvertiseRecording.WithheldShareIsNeverBlamedForAPeerDrop

DGB live path — drop the "peer that received nothing gets no record" skip:

[  FAILED  ] DgbReadvertiseRecording.PeerThatReceivedNothingIsNotRecorded

broadcast_and_mark() and readvertise_and_record() both deliberately take the offered batch as a parameter, so "record/mark the offered batch" is expressible at the primitive level and therefore detectable by the KAT.

Green runs (local, gcc-13 Release, same conan profile as CI)

btc_share_test                                        119 tests / 119 PASSED
dgb_share_test                                         46 tests /  46 PASSED
ctest -R '^(Btc|Dgb)(Broadcast|KnownTxs|Readvertise)'  22/22 passed
ctest -R '^bch_' (build_bch)                           31/31 passed
tools/ci/check_test_target_allowlist.py                OK, 119 targets across 5 lanes

Binaries build clean: c2pool (-DCOIN_DGB=ON) and c2pool-bch (-DCOIN_BCH=ON), so all three node.cpp TUs compile.

Not verified

• No integration test of the live call sites; the KATs pin the primitives those functions call. A reversion at a call site (re-inlining the old ordering) would not redden them. Mitigated by making the wrong policy expressible-and-detectable at the primitive, and by broadcast_share / readvertise_best_share having no other write into m_shared_share_hashes / m_last_broadcast_to.
• No live-network or soak validation of the gate under real sharereply-pulled shares.

For the integrator — follow-up de-duplication

A sibling lane is hoisting all_txs_backable into src/core/ for LTC. This PR deliberately does not create a competing src/core/ copy; it follows #868's per-coin header pattern. Once both land there will be four per-coin copies (btc, dgb, bch, dash) plus the core hoist — these should be collapsed onto the src/core/ version in a follow-up. A note to that effect is in each header. readvertise_and_record() is intentionally DGB-only, since DGB is the only coin with a de-dup-bypassing re-advert.

Ownership fences respected

Nothing touched in src/core/socket.cpp, src/core/web_server.cpp, src/impl/ltc/, src/impl/dash/, or any protocol_legacy.cpp.